package Persistencia.DAO;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.sql.Update;

import Persistencia.Entidad.Competencia;
import Persistencia.Entidad.EstadoDeCompetencia;
import Persistencia.Entidad.Fecha;
import Persistencia.Entidad.FormaDePuntuacion;
import Persistencia.Entidad.Deporte;
import Persistencia.Entidad.Localidad;
import Persistencia.Entidad.LugarDeCompetencia;
import Persistencia.Entidad.ModalidadDeCompetencia;
import Persistencia.Entidad.Pais;
import Persistencia.Entidad.Participante;
import Persistencia.Entidad.Provincia;
import Persistencia.Entidad.Reglamento;

public class DAOCompetencia {
	
	public Deporte getDeporte(int idDeporte) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    Deporte deporte = null;
	    
	    try {
	    	deporte = (Deporte) sesion.get(Deporte.class, idDeporte);
	    }
	    catch (Exception ex) {
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
		
		return deporte;
	}
	
	public ModalidadDeCompetencia getModalidad(int idModalidad) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    ModalidadDeCompetencia modalidad = null;
	    
	    try {
	    	modalidad = (ModalidadDeCompetencia) sesion.get(ModalidadDeCompetencia.class, idModalidad);
	    }
	    catch (Exception ex) {
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
		
		return modalidad;
	}
	
	public LugarDeCompetencia getLugarDeCompetencia(int idLugarDeCompetencia) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    LugarDeCompetencia lugar = null;
	    
	    try {
	    	lugar = (LugarDeCompetencia) sesion.get(LugarDeCompetencia.class, idLugarDeCompetencia);
	    }
	    catch (Exception ex) {
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
		
		return lugar;
	}

	public FormaDePuntuacion getFormaDePuntuacion(int idFormaDePuntuacion) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    FormaDePuntuacion formaDePuntuacion = null;
	    
	    try {
	    	formaDePuntuacion = (FormaDePuntuacion) sesion.get(FormaDePuntuacion.class, idFormaDePuntuacion);
	    }
	    catch (Exception ex) {
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
		
		return formaDePuntuacion;
	}

	public ArrayList<Deporte> getDeportes() {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    ArrayList<Deporte> deportes = null;
	    
	    try {
	    	deportes = (ArrayList<Deporte>) sesion.createQuery("from Deporte").list();
	    }
	    catch (Exception ex) {
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
		
		return deportes;
	}
	
	/**
	 * Retorna la Competencia con el <b>id</b> pasado como par�metro.<br>
	 * Si no existe una Competencia con ese id returna <b>null</b>.<br>
	 * Si la Competencia existe y ha finalizado o est� marcada como eliminada tambi�n retorna <b>null</b>.
	 * 
	 */
	public Competencia getCompetenciaHabilitada(int idCompetencia) {
		Competencia competencia = getCompetencia(idCompetencia);
		
		if (competencia != null && (competencia.getEliminada()
				|| competencia.getEstadoDeCompetencia().getId() == EstadoDeCompetencia.FINALIZADA)) {
			return null;
		}
		
		return competencia;
	}

	public void updateCompetencia(Competencia competencia) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    try {
	    	sesion.update(competencia);
		    sesion.getTransaction().commit();
	    }
	    catch (Exception ex) {
	    	sesion.getTransaction().rollback();
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
	}


	public Competencia getCompetencia(int idCompetencia) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    Competencia competencia = null;
	    
	    try {
	    	competencia = (Competencia) sesion.get(Competencia.class, idCompetencia);
	    }
	    catch (Exception ex) {
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
		
		return competencia;
	}
	
	public ArrayList<ModalidadDeCompetencia> getModalidades() {		
		SessionFactory sf = HibernateUtil.getSessionFactory();		
		Session sesion = sf.openSession();		
		sesion.beginTransaction();		
		
		ArrayList<ModalidadDeCompetencia> modalidades = null;		
		
		try {		
			modalidades = (ArrayList<ModalidadDeCompetencia>) sesion.createQuery("from ModalidadDeCompetencia").list();		
		}		
		catch (Exception ex) {
			ex.printStackTrace();
		}		
		finally {		
			sesion.close();		
		}		
		
			return modalidades;		
		}

	public Participante getParticipante(Integer idParticipante) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    Participante participante = null;
	    
	    try {
	    	participante = (Participante) sesion.get(Participante.class, idParticipante);
	    }
	    catch (Exception ex) {
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
		
		return participante;
	}

	public EstadoDeCompetencia getEstadoDeCompetencia(int idEstadoDeCompetencia) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    EstadoDeCompetencia estado = null;
	    
	    try {
	    	estado = (EstadoDeCompetencia) sesion.get(EstadoDeCompetencia.class, idEstadoDeCompetencia);
	    }
	    catch (Exception ex) {
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
		
		return estado;
	}

	public void saveCompetencia(Competencia competencia) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    try {
	    	sesion.save(competencia);
		    sesion.getTransaction().commit();
	    }
	    catch (Exception ex) {
	    	sesion.getTransaction().rollback();
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
	}

	public ArrayList<Competencia> getCompetencias() {
		SessionFactory sf = HibernateUtil.getSessionFactory();		
		Session sesion = sf.openSession();		
		sesion.beginTransaction();		
		
		ArrayList<Competencia> competencias = null;		
		
		try {		
			competencias = (ArrayList<Competencia>) sesion.createQuery("from Competencia").list();
		}		
		catch (Exception ex) {
			ex.printStackTrace();
		}		
		finally {		
			sesion.close();		
		}		
		
		return competencias;
	}

	public List<Participante> getParticipantes() {
		SessionFactory sf = HibernateUtil.getSessionFactory();		
		Session sesion = sf.openSession();		
		sesion.beginTransaction();		
		
		ArrayList<Participante> participantes = null;		
		
		try {		
			participantes = (ArrayList<Participante>) sesion.createQuery("from Participante").list();		
		}		
		catch (Exception ex) {
			ex.printStackTrace();
		}		
		finally {		
			sesion.close();		
		}		
		
		return participantes;
	}

	public void saveReglamento(Reglamento reglamento) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
	    Session sesion = sf.openSession();
	    sesion.beginTransaction();
	    
	    try {
	    	sesion.save(reglamento);
		    sesion.getTransaction().commit();
	    }
	    catch (Exception ex) {
	    	sesion.getTransaction().rollback();
	    	ex.printStackTrace();
	    }
	    finally {
	    	sesion.close();
	    }
	}

}